#include "music_player.h"
#include "myfont.h"
#include "smart_home_ui.h"
#include "mqtt_cloud.h"
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>

// 外部声明音乐图片（这些图片已编译到liblvgl.so动态库中）
extern const lv_img_dsc_t chunjiang;
extern const lv_img_dsc_t jinitaimei;
extern const lv_img_dsc_t shimianmaifu;
extern const lv_img_dsc_t liangzhu;
extern const lv_img_dsc_t erquanyingyue;

// 声明强制清屏函数
extern void force_clear_screen_ghosting(void);

// 界面元素
static lv_obj_t *music_screen = NULL;
static lv_obj_t *label_title = NULL;
static lv_obj_t *btn_back = NULL;
static lv_obj_t *music_time_label = NULL;
static lv_obj_t *music_date_label = NULL;
static lv_timer_t *music_timer_update = NULL;

// 音乐控制元素
static lv_obj_t *album_cover = NULL;
static lv_obj_t *song_title_label = NULL;
static lv_obj_t *artist_label = NULL;
static lv_obj_t *progress_bar = NULL;
static lv_obj_t *current_time_label = NULL;
static lv_obj_t *total_time_label = NULL;
static lv_obj_t *volume_slider = NULL;
static lv_obj_t *volume_label = NULL;

// 播放控制按钮
static lv_obj_t *btn_previous = NULL;
static lv_obj_t *btn_play_pause = NULL;
static lv_obj_t *btn_next = NULL;
static lv_obj_t *btn_mode = NULL;

// 播放列表
static lv_obj_t *playlist_container = NULL;
static lv_obj_t *playlist_list = NULL;

// 全局状态
static music_state_t current_state = MUSIC_STATE_STOPPED;
static music_mode_t current_mode = MUSIC_MODE_REPEAT;  // 默认为循环播放
static int current_volume = 50;
static int current_progress = 0;
static int current_song_index = 0;
static int elapsed_seconds = 0;  // 当前歌曲已播放的秒数
static int progress_counter = 0; // 进度条更新计数器
static int cloud_upload_counter = 0; // 云平台上传计数器

// 示例音乐列表
static const char *song_titles[] = {
    "春江花月夜",
    "鸡你太美",
    "十面埋伏",
    "梁祝",
    "二泉映月"
};

static const char *song_artists[] = {
    "古典音乐",
    "世界名曲",
    "琵琶独奏",
    "小提琴协奏",
    "二胡名曲"
};

// 歌曲专辑封面图片数组（按歌曲顺序排列）
static const lv_img_dsc_t *song_covers[] = {
    &chunjiang,      // 春江花月夜
    &jinitaimei,     // 鸡你太美
    &shimianmaifu,   // 十面埋伏
    &liangzhu,       // 梁祝
    &erquanyingyue   // 二泉映月
};

// 随机播放相关变量
static int shuffle_playlist[5];  // 随机播放列表
static int shuffle_position = 0; // 当前在随机列表中的位置
static bool shuffle_initialized = false; // 随机列表是否已初始化

// 函数声明
static void update_current_song_info(void);
static void update_playlist_highlight(void);
static void init_shuffle_playlist(void);
static int get_next_shuffle_song(void);
static int get_previous_shuffle_song(void);
static void upload_music_status_to_cloud(void);

/**
 * @brief 音乐界面时间更新定时器回调函数
 * @param timer 定时器对象指针
 * @note 每秒调用一次，负责更新界面时间显示和播放进度
 *       - 更新右上角的系统时间和日期
 *       - 更新播放进度条和播放时间
 *       - 检查歌曲是否播放完成，自动切换下一首
 */
static void music_update_time_task(lv_timer_t *timer) {
    static time_t last_update_s = 0;
    static char last_date_str[32] = "";
    static char last_time_str[32] = "";
    
    time_t now;
    time(&now);
    
    // 当timer为NULL时（手动调用），强制更新一次
    bool force_update = (timer == NULL);
    
    // 仅在秒有变化时更新，避免重复重绘
    if(!force_update && now == last_update_s) return;
    last_update_s = now;
    if(music_date_label == NULL || music_time_label == NULL) return;
    
    time_t raw_time;
    struct tm *time_info;
    char date_str[32];
    char time_str[32];
    
    raw_time = now;
    time_info = localtime(&raw_time);
    
    // 分别格式化日期和时间
    strftime(date_str, sizeof(date_str), "%Y-%m-%d", time_info);
    strftime(time_str, sizeof(time_str), "%H:%M:%S", time_info);
    
    // 设置日期和时间标签文本
    if(force_update || strcmp(last_date_str, date_str) != 0) {
        lv_label_set_text(music_date_label, date_str);
        strcpy(last_date_str, date_str);
    }
    if(force_update || strcmp(last_time_str, time_str) != 0) {
        lv_label_set_text(music_time_label, time_str);
        strcpy(last_time_str, time_str);
    }
    
    // 模拟播放进度更新
    if(current_state == MUSIC_STATE_PLAYING) {
        // 每秒递增时间
        elapsed_seconds++;
        progress_counter++;
        cloud_upload_counter++;
        
        // 每1.8秒增加1%的进度（180秒总时长，100%进度）
        if(progress_counter >= 2) {  // 约每1.8秒更新一次进度条
            current_progress += 1;
            progress_counter = 0;
        }
        
        // 更新界面进度条（如果界面存在）
        if(progress_bar) {
            lv_slider_set_value(progress_bar, current_progress, LV_ANIM_OFF);
        }
        
        // 检查是否播放完成
        if(elapsed_seconds >= 180) {  // 3分钟播放完成
            // 自动播放下一首（会在update_current_song_info中重置所有状态）
            music_next();
        }
        
        // 更新界面时间显示（如果界面存在）
        if(current_time_label) {
            int current_min = elapsed_seconds / 60;
            int current_sec = elapsed_seconds % 60;
            char music_time_str[16];
            snprintf(music_time_str, sizeof(music_time_str), "%02d:%02d", current_min, current_sec);
            lv_label_set_text(current_time_label, music_time_str);
        }
        
        // 每15秒上传一次播放状态到云平台（避免过于频繁的上传）
        if(cloud_upload_counter >= 15) {
            upload_music_status_to_cloud();
            cloud_upload_counter = 0;
        }
    }
}

/**
 * @brief 返回按钮点击事件回调函数
 * @param e 事件对象指针
 * @note 处理返回按钮点击事件，返回到智能家居主界面
 */
static void back_btn_event_cb(lv_event_t *e) {
    if(lv_event_get_code(e) != LV_EVENT_CLICKED) return;
    
    // 使用安全的返回方式，避免在事件回调中直接删除当前屏幕
    return_to_smart_home_ui();
}

/**
 * @brief 播放/暂停按钮点击事件回调函数
 * @param e 事件对象指针
 * @note 处理播放/暂停按钮点击事件，切换播放状态
 *       - 如果正在播放，则暂停播放
 *       - 如果已暂停或停止，则开始播放
 */
static void play_pause_btn_event_cb(lv_event_t *e) {
    if(lv_event_get_code(e) != LV_EVENT_CLICKED) return;
    
    if(current_state == MUSIC_STATE_PLAYING) {
        music_pause();
    } else {
        music_play();
    }
}

/**
 * @brief 上一首按钮点击事件回调函数
 * @param e 事件对象指针
 * @note 处理上一首按钮点击事件，切换到上一首歌曲
 */
static void previous_btn_event_cb(lv_event_t *e) {
    if(lv_event_get_code(e) != LV_EVENT_CLICKED) return;
    music_previous();
}

/**
 * @brief 下一首按钮点击事件回调函数
 * @param e 事件对象指针
 * @note 处理下一首按钮点击事件，切换到下一首歌曲
 */
static void next_btn_event_cb(lv_event_t *e) {
    if(lv_event_get_code(e) != LV_EVENT_CLICKED) return;
    music_next();
}

/**
 * @brief 播放模式按钮点击事件回调函数
 * @param e 事件对象指针
 * @note 处理播放模式按钮点击事件，在两种播放模式间切换
 *       - 循环播放 <-> 随机播放
 *       - 更新按钮图标显示当前模式
 */
static void mode_btn_event_cb(lv_event_t *e) {
    if(lv_event_get_code(e) != LV_EVENT_CLICKED) return;
    
    // 在循环播放和随机播放之间切换
    current_mode = (current_mode == MUSIC_MODE_REPEAT) ? MUSIC_MODE_SHUFFLE : MUSIC_MODE_REPEAT;
    
    // 如果切换到随机播放模式，重新初始化随机列表
    if(current_mode == MUSIC_MODE_SHUFFLE) {
        shuffle_initialized = false;  // 标记需要重新初始化
    }
    
    // 更新按钮显示
    if(btn_mode) {
        const char *mode_text;
        switch(current_mode) {
            case MUSIC_MODE_REPEAT: mode_text = LV_SYMBOL_LOOP; break;
            case MUSIC_MODE_SHUFFLE: mode_text = LV_SYMBOL_SHUFFLE; break;
            default: mode_text = LV_SYMBOL_LOOP; break;
        }
        lv_obj_t *mode_label = lv_obj_get_child(btn_mode, 0);
        if(mode_label) {
            lv_label_set_text(mode_label, mode_text);
            // 确保字体设置正确
            lv_obj_set_style_text_font(mode_label, &lv_font_montserrat_20, 0);
        }
    }
}

/**
 * @brief 音量滑块值变化事件回调函数
 * @param e 事件对象指针
 * @note 处理音量滑块值变化事件，更新音量设置和显示
 *       - 获取滑块当前值作为音量百分比
 *       - 更新音量标签显示
 */
static void volume_slider_event_cb(lv_event_t *e) {
    lv_obj_t *slider = lv_event_get_target(e);
    int32_t value = lv_slider_get_value(slider);
    
    current_volume = value;
    
    // 更新音量标签
    if(volume_label) {
        char buf[16];
        snprintf(buf, sizeof(buf), "音量: %d%%", current_volume);
        lv_label_set_text(volume_label, buf);
    }
    
    // 上传音量变更到云平台
    upload_music_status_to_cloud();
}

/**
 * @brief 进度条拖动/点击事件回调函数
 * @param e 事件对象指针
 * @note 处理进度条拖动和点击事件，实现播放位置跳转
 *       - 支持点击进度条跳转到指定位置
 *       - 支持拖动进度条实时调整播放位置
 *       - 同步更新播放时间显示
 */
static void progress_event_cb(lv_event_t *e) {
    lv_event_code_t code = lv_event_get_code(e);
    
    if(code == LV_EVENT_VALUE_CHANGED) {
        lv_obj_t *slider = lv_event_get_target(e);
        int32_t new_progress = lv_slider_get_value(slider);
        
        // 更新全局进度
        current_progress = new_progress;
        
        // 根据进度计算新的播放时间（假设歌曲总长度为180秒）
        elapsed_seconds = (new_progress * 180) / 100;
        progress_counter = new_progress;
        
        // 更新时间显示
        if(current_time_label) {
            int current_min = elapsed_seconds / 60;
            int current_sec = elapsed_seconds % 60;
            char time_str[16];
            snprintf(time_str, sizeof(time_str), "%02d:%02d", current_min, current_sec);
            lv_label_set_text(current_time_label, time_str);
        }
    }
}

/**
 * @brief 播放列表项点击事件回调函数
 * @param e 事件对象指针
 * @note 处理播放列表项点击事件，切换到选中的歌曲
 *       - 遍历播放列表找到被点击的项目
 *       - 更新当前歌曲索引
 *       - 调用统一的歌曲信息更新函数
 */
static void playlist_item_event_cb(lv_event_t *e) {
    if(lv_event_get_code(e) != LV_EVENT_CLICKED) return;
    
    lv_obj_t *item = lv_event_get_target(e);
    // 获取点击的项目索引
    for(int i = 0; i < 5; i++) {
        lv_obj_t *child = lv_obj_get_child(playlist_list, i);
        if(child == item) {
            current_song_index = i;
            
            // 如果是随机播放模式，需要更新随机列表中的位置
            if(current_mode == MUSIC_MODE_SHUFFLE && shuffle_initialized) {
                for(int j = 0; j < 5; j++) {
                    if(shuffle_playlist[j] == i) {
                        shuffle_position = j;
                        break;
                    }
                }
            }
            
            // 使用统一的更新函数
            update_current_song_info();
            break;
        }
    }
}

/**
 * @brief 初始化随机播放列表
 * @note 生成一个包含所有歌曲索引的随机序列
 *       - 使用Fisher-Yates洗牌算法
 *       - 确保每首歌曲都会被播放到
 *       - 避免连续播放同一首歌曲
 */
static void init_shuffle_playlist(void) {
    // 初始化播放列表为顺序序列
    for(int i = 0; i < 5; i++) {
        shuffle_playlist[i] = i;
    }
    
    // 使用当前时间作为随机种子
    srand((unsigned int)time(NULL));
    
    // Fisher-Yates洗牌算法
    for(int i = 4; i > 0; i--) {
        int j = rand() % (i + 1);
        // 交换元素
        int tmp_val = shuffle_playlist[i];
        shuffle_playlist[i] = shuffle_playlist[j];
        shuffle_playlist[j] = tmp_val;
    }
    
    // 找到当前歌曲在随机列表中的位置
    for(int i = 0; i < 5; i++) {
        if(shuffle_playlist[i] == current_song_index) {
            shuffle_position = i;
            break;
        }
    }
    
    shuffle_initialized = true;
}

/**
 * @brief 获取随机播放模式下的下一首歌曲索引
 * @return 下一首歌曲的索引
 */
static int get_next_shuffle_song(void) {
    if(!shuffle_initialized) {
        init_shuffle_playlist();
    }
    
    shuffle_position = (shuffle_position + 1) % 5;
    return shuffle_playlist[shuffle_position];
}

/**
 * @brief 获取随机播放模式下的上一首歌曲索引
 * @return 上一首歌曲的索引
 */
static int get_previous_shuffle_song(void) {
    if(!shuffle_initialized) {
        init_shuffle_playlist();
    }
    
    shuffle_position = (shuffle_position - 1 + 5) % 5;
    return shuffle_playlist[shuffle_position];
}

/**
 * @brief 更新播放列表高亮显示函数
 * @note 更新播放列表中所有项目的背景色
 *       - 当前播放的歌曲显示为高亮背景色（深紫色）
 *       - 其他歌曲显示为普通背景色（深蓝色）
 *       - 确保用户能清楚看到当前播放的歌曲
 */
static void update_playlist_highlight(void) {
    if(playlist_list) {
        // 更新所有播放列表项的背景色
        for(int i = 0; i < 5; i++) {
            lv_obj_t *item = lv_obj_get_child(playlist_list, i);
            if(item) {
                // 当前歌曲高亮显示，其他歌曲恢复普通背景
                lv_color_t bg_color = (i == current_song_index) ? 
                    lv_color_hex(0x533a7b) : lv_color_hex(0x16213e);
                lv_obj_set_style_bg_color(item, bg_color, 0);
            }
        }
    }
}

/**
 * @brief 更新当前歌曲信息函数
 * @note 统一更新当前歌曲的所有显示信息
 *       - 更新歌曲标题和艺术家标签
 *       - 重置播放进度条和播放时间
 *       - 重置播放计时器相关变量
 *       - 更新播放列表高亮显示
 */
static void update_current_song_info(void) {
    // 更新界面显示（如果界面存在）
    if(song_title_label) lv_label_set_text(song_title_label, song_titles[current_song_index]);
    if(artist_label) lv_label_set_text(artist_label, song_artists[current_song_index]);
    
    // 更新专辑封面图片（如果界面存在）
    if(album_cover) lv_img_set_src(album_cover, song_covers[current_song_index]);
    
    // 重置播放状态（无论界面是否存在都要重置）
    current_progress = 0;
    elapsed_seconds = 0;     // 重置播放时间
    progress_counter = 0;    // 重置进度计数器
    cloud_upload_counter = 0; // 重置云平台上传计数器
    
    // 更新界面控件（如果界面存在）
    if(progress_bar) lv_slider_set_value(progress_bar, 0, LV_ANIM_OFF);
    if(current_time_label) lv_label_set_text(current_time_label, "00:00");
    
    // 更新播放列表高亮（如果界面存在）
    update_playlist_highlight();
    
    // 上传歌曲切换信息到云平台
    upload_music_status_to_cloud();
}

/**
 * @brief 创建音乐播放器界面
 * @note 创建完整的音乐播放器用户界面
 *       - 创建屏幕背景和基本布局
 *       - 创建标题栏、返回按钮、时间显示
 *       - 创建专辑封面、歌曲信息区域
 *       - 创建播放控制按钮（播放/暂停、上一首、下一首、模式切换）
 *       - 创建进度条和时间显示
 *       - 创建音量控制滑块
 *       - 创建播放列表
 *       - 启动定时器和初始化界面状态
 */
void create_music_player_screen(void) {
    // 清理旧的对象引用
    music_screen = NULL;
    label_title = NULL;
    btn_back = NULL;
    music_time_label = NULL;
    music_date_label = NULL;
    if(music_timer_update) {
        lv_timer_del(music_timer_update);
        music_timer_update = NULL;
    }
    

    
    // 创建新的音乐屏幕
    music_screen = lv_obj_create(NULL);
    lv_obj_set_style_bg_color(music_screen, lv_color_hex(0x1a1a2e), LV_PART_MAIN);  // 深紫色背景
    lv_obj_set_style_bg_opa(music_screen, LV_OPA_COVER, LV_PART_MAIN);
    lv_obj_clear_flag(music_screen, LV_OBJ_FLAG_SCROLLABLE);

    // 标题
    label_title = lv_label_create(music_screen);
    lv_obj_set_style_text_font(label_title, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(label_title, lv_color_hex(0xecf0f1), LV_PART_MAIN);
    lv_label_set_text(label_title, LV_SYMBOL_AUDIO " 音乐播放器");
    lv_obj_align(label_title, LV_ALIGN_TOP_MID, 0, 6);

    // 返回按钮（左上角）
    btn_back = lv_btn_create(music_screen);
    lv_obj_set_size(btn_back, 72, 40);
    lv_obj_align(btn_back, LV_ALIGN_TOP_LEFT, 12, 10);
    lv_obj_set_style_bg_color(btn_back, lv_color_hex(0x16213e), 0);
    lv_obj_set_style_radius(btn_back, 8, 0);
    lv_obj_set_style_border_width(btn_back, 0, 0);
    lv_obj_t *lbl_back = lv_label_create(btn_back);
    lv_obj_set_style_text_font(lbl_back, &lv_font_source_han_sans_bold_20, 0);
    lv_obj_set_style_text_color(lbl_back, lv_color_hex(0xFFFFFF), 0);
    lv_label_set_text(lbl_back, LV_SYMBOL_LEFT " 返回");
    lv_obj_center(lbl_back);
    lv_obj_add_event_cb(btn_back, back_btn_event_cb, LV_EVENT_ALL, NULL);

    // 添加时间显示（右上角）
    // 日期时间标签（右上角，贴着屏幕右侧）
    music_date_label = lv_label_create(music_screen);
    lv_obj_set_style_text_font(music_date_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(music_date_label, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
    lv_label_set_text(music_date_label, "加载中...");
    lv_obj_align(music_date_label, LV_ALIGN_TOP_RIGHT, -5, 10);  // 与其他页面一致，贴近右侧

    music_time_label = lv_label_create(music_screen);
    lv_obj_set_style_text_font(music_time_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(music_time_label, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
    lv_label_set_text(music_time_label, "加载中...");
    lv_obj_align(music_time_label, LV_ALIGN_TOP_RIGHT, -5, 40);  // 使用绝对定位，确保右侧完全对齐

    // 创建主要内容区域
    lv_obj_t *content_area = lv_obj_create(music_screen);
    lv_obj_set_size(content_area, 950, 500);
    lv_obj_align(content_area, LV_ALIGN_CENTER, 0, 20);
    lv_obj_set_style_bg_color(content_area, lv_color_hex(0x16213e), LV_PART_MAIN);
    lv_obj_set_style_radius(content_area, 15, LV_PART_MAIN);
    lv_obj_set_style_border_width(content_area, 0, LV_PART_MAIN);
    lv_obj_set_style_shadow_width(content_area, 0, LV_PART_MAIN);
    lv_obj_set_style_pad_all(content_area, 20, LV_PART_MAIN);

    // 专辑封面区域（使用图片对象）
    album_cover = lv_img_create(content_area);
    lv_obj_set_size(album_cover, 200, 200);
    lv_obj_align(album_cover, LV_ALIGN_TOP_LEFT, 20, 20);
    lv_img_set_src(album_cover, song_covers[current_song_index]);
    
    // 设置专辑封面样式
    lv_obj_set_style_radius(album_cover, 15, LV_PART_MAIN);
    lv_obj_set_style_border_width(album_cover, 2, LV_PART_MAIN);
    lv_obj_set_style_border_color(album_cover, lv_color_hex(0x533a7b), LV_PART_MAIN);
    lv_obj_set_style_clip_corner(album_cover, true, LV_PART_MAIN);  // 确保圆角裁剪生效

    // 歌曲信息区域
    song_title_label = lv_label_create(content_area);
    lv_obj_set_style_text_font(song_title_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(song_title_label, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
    lv_label_set_text(song_title_label, song_titles[current_song_index]);
    lv_obj_align(song_title_label, LV_ALIGN_TOP_LEFT, 260, 40);

    artist_label = lv_label_create(content_area);
    lv_obj_set_style_text_font(artist_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(artist_label, lv_color_hex(0xbdc3c7), LV_PART_MAIN);
    lv_label_set_text(artist_label, song_artists[current_song_index]);
    lv_obj_align_to(artist_label, song_title_label, LV_ALIGN_OUT_BOTTOM_LEFT, 0, 10);

    // 进度条（使用滑块实现可拖动功能）
    progress_bar = lv_slider_create(content_area);
    lv_obj_set_size(progress_bar, 400, 20);
    lv_obj_align(progress_bar, LV_ALIGN_TOP_LEFT, 260, 120);
    lv_slider_set_range(progress_bar, 0, 100);
    lv_slider_set_value(progress_bar, current_progress, LV_ANIM_OFF);
    lv_obj_set_style_bg_color(progress_bar, lv_color_hex(0x34495e), LV_PART_MAIN);
    lv_obj_set_style_bg_color(progress_bar, lv_color_hex(0x9b59b6), LV_PART_INDICATOR);
    lv_obj_set_style_bg_color(progress_bar, lv_color_hex(0x9b59b6), LV_PART_KNOB);
    lv_obj_set_style_radius(progress_bar, LV_RADIUS_CIRCLE, LV_PART_KNOB);
    lv_obj_add_event_cb(progress_bar, progress_event_cb, LV_EVENT_VALUE_CHANGED, NULL);

    // 时间显示
    current_time_label = lv_label_create(content_area);
    lv_obj_set_style_text_font(current_time_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(current_time_label, lv_color_hex(0xbdc3c7), LV_PART_MAIN);
    // 根据当前播放时间设置显示
    int current_min = elapsed_seconds / 60;
    int current_sec = elapsed_seconds % 60;
    char time_str[16];
    snprintf(time_str, sizeof(time_str), "%02d:%02d", current_min, current_sec);
    lv_label_set_text(current_time_label, time_str);
    lv_obj_align_to(current_time_label, progress_bar, LV_ALIGN_OUT_BOTTOM_LEFT, 0, 10);

    total_time_label = lv_label_create(content_area);
    lv_obj_set_style_text_font(total_time_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(total_time_label, lv_color_hex(0xbdc3c7), LV_PART_MAIN);
    lv_label_set_text(total_time_label, "03:00");
    lv_obj_align_to(total_time_label, progress_bar, LV_ALIGN_OUT_BOTTOM_RIGHT, 0, 10);

    // 播放控制按钮区域
    int btn_y = 280;
    
    // 上一首按钮
    btn_previous = lv_btn_create(content_area);
    lv_obj_set_size(btn_previous, 60, 60);
    lv_obj_align(btn_previous, LV_ALIGN_TOP_LEFT, 180, btn_y);
    lv_obj_set_style_bg_color(btn_previous, lv_color_hex(0x533a7b), 0);
    lv_obj_set_style_radius(btn_previous, LV_RADIUS_CIRCLE, 0);
    lv_obj_t *prev_icon = lv_label_create(btn_previous);
    lv_obj_set_style_text_font(prev_icon, &lv_font_montserrat_20, 0);  // 使用包含符号的Montserrat字体
    lv_obj_set_style_text_color(prev_icon, lv_color_hex(0xFFFFFF), 0);
    lv_label_set_text(prev_icon, LV_SYMBOL_PREV);
    lv_obj_center(prev_icon);
    lv_obj_add_event_cb(btn_previous, previous_btn_event_cb, LV_EVENT_CLICKED, NULL);

    // 播放/暂停按钮（大一些）
    btn_play_pause = lv_btn_create(content_area);
    lv_obj_set_size(btn_play_pause, 80, 80);
    lv_obj_align(btn_play_pause, LV_ALIGN_TOP_LEFT, 270, btn_y - 10);
    lv_obj_set_style_bg_color(btn_play_pause, lv_color_hex(0x9b59b6), 0);
    lv_obj_set_style_radius(btn_play_pause, LV_RADIUS_CIRCLE, 0);
    lv_obj_t *play_icon = lv_label_create(btn_play_pause);
    lv_obj_set_style_text_font(play_icon, &lv_font_montserrat_20, 0);  // 使用包含符号的Montserrat字体
    lv_obj_set_style_text_color(play_icon, lv_color_hex(0xFFFFFF), 0);
    lv_label_set_text(play_icon, LV_SYMBOL_PLAY);
    lv_obj_center(play_icon);
    lv_obj_add_event_cb(btn_play_pause, play_pause_btn_event_cb, LV_EVENT_CLICKED, NULL);

    // 下一首按钮
    btn_next = lv_btn_create(content_area);
    lv_obj_set_size(btn_next, 60, 60);
    lv_obj_align(btn_next, LV_ALIGN_TOP_LEFT, 380, btn_y);
    lv_obj_set_style_bg_color(btn_next, lv_color_hex(0x533a7b), 0);
    lv_obj_set_style_radius(btn_next, LV_RADIUS_CIRCLE, 0);
    lv_obj_t *next_icon = lv_label_create(btn_next);
    lv_obj_set_style_text_font(next_icon, &lv_font_montserrat_20, 0);  // 使用包含符号的Montserrat字体
    lv_obj_set_style_text_color(next_icon, lv_color_hex(0xFFFFFF), 0);
    lv_label_set_text(next_icon, LV_SYMBOL_NEXT);
    lv_obj_center(next_icon);
    lv_obj_add_event_cb(btn_next, next_btn_event_cb, LV_EVENT_CLICKED, NULL);

    // 播放模式按钮
    btn_mode = lv_btn_create(content_area);
    lv_obj_set_size(btn_mode, 50, 50);
    lv_obj_align(btn_mode, LV_ALIGN_TOP_LEFT, 460, btn_y + 5);
    lv_obj_set_style_bg_color(btn_mode, lv_color_hex(0x34495e), 0);
    lv_obj_set_style_radius(btn_mode, LV_RADIUS_CIRCLE, 0);
    lv_obj_t *mode_icon = lv_label_create(btn_mode);
    lv_obj_set_style_text_font(mode_icon, &lv_font_montserrat_20, 0);  // 使用包含符号的Montserrat字体
    lv_obj_set_style_text_color(mode_icon, lv_color_hex(0xFFFFFF), 0);
    lv_label_set_text(mode_icon, LV_SYMBOL_LOOP);  // 默认显示循环播放符号
    lv_obj_center(mode_icon);
    lv_obj_add_event_cb(btn_mode, mode_btn_event_cb, LV_EVENT_CLICKED, NULL);

    // 音量控制
    volume_label = lv_label_create(content_area);
    lv_obj_set_style_text_font(volume_label, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(volume_label, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
    // 根据当前音量设置显示
    char volume_str[16];
    snprintf(volume_str, sizeof(volume_str), "音量: %d%%", current_volume);
    lv_label_set_text(volume_label, volume_str);
    lv_obj_align(volume_label, LV_ALIGN_TOP_LEFT, 260, 200);

    volume_slider = lv_slider_create(content_area);
    lv_obj_set_size(volume_slider, 200, 20);
    lv_obj_align_to(volume_slider, volume_label, LV_ALIGN_OUT_BOTTOM_LEFT, 0, 10);
    lv_slider_set_range(volume_slider, 0, 100);
    lv_slider_set_value(volume_slider, current_volume, LV_ANIM_OFF);
    lv_obj_set_style_bg_color(volume_slider, lv_color_hex(0x34495e), LV_PART_MAIN);
    lv_obj_set_style_bg_color(volume_slider, lv_color_hex(0x9b59b6), LV_PART_INDICATOR);
    lv_obj_set_style_bg_color(volume_slider, lv_color_hex(0xecf0f1), LV_PART_KNOB);
    lv_obj_add_event_cb(volume_slider, volume_slider_event_cb, LV_EVENT_VALUE_CHANGED, NULL);

    // 播放列表区域
    playlist_container = lv_obj_create(content_area);
    lv_obj_set_size(playlist_container, 200, 350);
    lv_obj_align(playlist_container, LV_ALIGN_TOP_RIGHT, -20, 20);
    lv_obj_set_style_bg_color(playlist_container, lv_color_hex(0x0f3460), LV_PART_MAIN);
    lv_obj_set_style_radius(playlist_container, 10, LV_PART_MAIN);
    lv_obj_set_style_border_width(playlist_container, 1, LV_PART_MAIN);
    lv_obj_set_style_border_color(playlist_container, lv_color_hex(0x533a7b), LV_PART_MAIN);
    lv_obj_set_style_pad_all(playlist_container, 10, LV_PART_MAIN);

    // 播放列表标题
    lv_obj_t *playlist_title = lv_label_create(playlist_container);
    lv_obj_set_style_text_font(playlist_title, &lv_font_source_han_sans_bold_20, LV_PART_MAIN);
    lv_obj_set_style_text_color(playlist_title, lv_color_hex(0xFFFFFF), LV_PART_MAIN);
    lv_label_set_text(playlist_title, "播放列表");
    lv_obj_align(playlist_title, LV_ALIGN_TOP_MID, 0, 5);

    // 播放列表
    playlist_list = lv_obj_create(playlist_container);
    lv_obj_set_size(playlist_list, 180, 280);
    lv_obj_align(playlist_list, LV_ALIGN_TOP_MID, 0, 40);
    lv_obj_set_style_bg_opa(playlist_list, LV_OPA_TRANSP, LV_PART_MAIN);
    lv_obj_set_style_border_width(playlist_list, 0, LV_PART_MAIN);
    lv_obj_set_style_pad_all(playlist_list, 5, LV_PART_MAIN);

    // 创建播放列表项
    for(int i = 0; i < 5; i++) {
        lv_obj_t *item = lv_btn_create(playlist_list);
        lv_obj_set_size(item, 170, 45);
        lv_obj_align(item, LV_ALIGN_TOP_MID, 0, i * 55);
        lv_obj_set_style_bg_color(item, lv_color_hex(i == current_song_index ? 0x533a7b : 0x16213e), 0);
        lv_obj_set_style_radius(item, 8, 0);
        lv_obj_set_style_border_width(item, 0, 0);
        
        lv_obj_t *item_label = lv_label_create(item);
        lv_obj_set_style_text_font(item_label, &lv_font_source_han_sans_bold_20, 0);
        lv_obj_set_style_text_color(item_label, lv_color_hex(0xFFFFFF), 0);
        lv_label_set_text(item_label, song_titles[i]);
        lv_obj_center(item_label);
        
        lv_obj_add_event_cb(item, playlist_item_event_cb, LV_EVENT_CLICKED, NULL);
    }

    // 创建时间更新定时器
    music_timer_update = lv_timer_create(music_update_time_task, 1000, NULL);
    // 立即更新一次时间
    music_update_time_task(NULL);
    
    // 初始化播放列表高亮显示
    update_playlist_highlight();
    
    // 根据当前播放状态同步播放按钮显示
    if(btn_play_pause) {
        lv_obj_t *play_button_icon = lv_obj_get_child(btn_play_pause, 0);
        if(play_button_icon) {
            // 根据当前播放状态设置正确的符号
            if(current_state == MUSIC_STATE_PLAYING) {
                lv_label_set_text(play_button_icon, LV_SYMBOL_PAUSE);
            } else {
                lv_label_set_text(play_button_icon, LV_SYMBOL_PLAY);
            }
            // 确保字体设置正确
            lv_obj_set_style_text_font(play_button_icon, &lv_font_montserrat_20, 0);
        }
    }
    
    // 根据当前播放模式同步模式按钮显示
    if(btn_mode) {
        lv_obj_t *mode_button_icon = lv_obj_get_child(btn_mode, 0);
        if(mode_button_icon) {
            // 根据当前播放模式设置正确的符号
            const char *mode_text;
            switch(current_mode) {
                case MUSIC_MODE_REPEAT: mode_text = LV_SYMBOL_LOOP; break;
                case MUSIC_MODE_SHUFFLE: mode_text = LV_SYMBOL_SHUFFLE; break;
                default: mode_text = LV_SYMBOL_LOOP; break;
            }
            lv_label_set_text(mode_button_icon, mode_text);
            // 确保字体设置正确
            lv_obj_set_style_text_font(mode_button_icon, &lv_font_montserrat_20, 0);
        }
    }
    
    // 同步音量显示
    if(volume_label) {
        char volume_sync_str[16];
        snprintf(volume_sync_str, sizeof(volume_sync_str), "音量: %d%%", current_volume);
        lv_label_set_text(volume_label, volume_sync_str);
    }
    if(volume_slider) {
        lv_slider_set_value(volume_slider, current_volume, LV_ANIM_OFF);
    }
    
    // 同步播放进度和时间显示
    if(progress_bar) {
        lv_slider_set_value(progress_bar, current_progress, LV_ANIM_OFF);
    }
    if(current_time_label) {
        int sync_min = elapsed_seconds / 60;
        int sync_sec = elapsed_seconds % 60;
        char sync_time_str[16];
        snprintf(sync_time_str, sizeof(sync_time_str), "%02d:%02d", sync_min, sync_sec);
        lv_label_set_text(current_time_label, sync_time_str);
    }
    
    // 使用安全的屏幕切换方式，避免段错误
    // 使用快速淡入动画，提供更流畅的切换体验
    lv_scr_load_anim(music_screen, LV_SCR_LOAD_ANIM_FADE_ON, 100, 0, false);
    
    // 让LVGL自动处理旧屏幕清理，避免手动删除导致的内存问题
}

/**
 * @brief 清理音乐播放器界面资源
 * @note 释放音乐播放器界面的所有资源
 *       - 删除定时器，防止内存泄漏
 *       - 清空所有界面对象指针
 *       - 重置界面状态为初始状态
 */
void cleanup_music_player_ui(void) {
    // 清理定时器
    if(music_timer_update) {
        lv_timer_del(music_timer_update);
        music_timer_update = NULL;
    }
    
    // 清理对象指针
    music_screen = NULL;
    label_title = NULL;
    btn_back = NULL;
    music_time_label = NULL;
    music_date_label = NULL;
    album_cover = NULL;
    song_title_label = NULL;
    artist_label = NULL;
    progress_bar = NULL;
    current_time_label = NULL;
    total_time_label = NULL;
    volume_slider = NULL;
    volume_label = NULL;
    btn_previous = NULL;
    btn_play_pause = NULL;
    btn_next = NULL;
    btn_mode = NULL;
    playlist_container = NULL;
    playlist_list = NULL;
}

/**
 * @brief 开始播放音乐
 * @note 设置播放状态为播放中，更新播放按钮图标为暂停图标
 */
void music_play(void) {
    current_state = MUSIC_STATE_PLAYING;
    if(btn_play_pause) {
        lv_obj_t *play_icon = lv_obj_get_child(btn_play_pause, 0);
        if(play_icon) {
            lv_label_set_text(play_icon, LV_SYMBOL_PAUSE);
            // 确保字体设置正确
            lv_obj_set_style_text_font(play_icon, &lv_font_montserrat_20, 0);
        }
    }
    
    // 上传播放状态到云平台
    upload_music_status_to_cloud();
}

/**
 * @brief 暂停播放音乐
 * @note 设置播放状态为暂停，更新播放按钮图标为播放图标
 */
void music_pause(void) {
    current_state = MUSIC_STATE_PAUSED;
    if(btn_play_pause) {
        lv_obj_t *play_icon = lv_obj_get_child(btn_play_pause, 0);
        if(play_icon) {
            lv_label_set_text(play_icon, LV_SYMBOL_PLAY);
            // 确保字体设置正确
            lv_obj_set_style_text_font(play_icon, &lv_font_montserrat_20, 0);
        }
    }
    
    // 上传播放状态到云平台
    upload_music_status_to_cloud();
}

/**
 * @brief 停止播放音乐
 * @note 设置播放状态为停止，重置进度条，更新播放按钮图标为播放图标
 */
void music_stop(void) {
    current_state = MUSIC_STATE_STOPPED;
    current_progress = 0;
    if(progress_bar) lv_slider_set_value(progress_bar, 0, LV_ANIM_OFF);
    if(btn_play_pause) {
        lv_obj_t *play_icon = lv_obj_get_child(btn_play_pause, 0);
        if(play_icon) {
            lv_label_set_text(play_icon, LV_SYMBOL_PLAY);
            // 确保字体设置正确
            lv_obj_set_style_text_font(play_icon, &lv_font_montserrat_20, 0);
        }
    }
    
    // 上传播放状态到云平台
    upload_music_status_to_cloud();
}

/**
 * @brief 播放下一首歌曲
 * @note 根据当前播放模式选择下一首歌曲
 *       - 循环播放：按顺序播放下一首
 *       - 随机播放：根据随机列表播放下一首
 */
void music_next(void) {
    if(current_mode == MUSIC_MODE_SHUFFLE) {
        current_song_index = get_next_shuffle_song();
    } else {
        // 循环播放模式
        current_song_index = (current_song_index + 1) % 5;
    }
    update_current_song_info();
}

/**
 * @brief 播放上一首歌曲
 * @note 根据当前播放模式选择上一首歌曲
 *       - 循环播放：按顺序播放上一首
 *       - 随机播放：根据随机列表播放上一首
 */
void music_previous(void) {
    if(current_mode == MUSIC_MODE_SHUFFLE) {
        current_song_index = get_previous_shuffle_song();
    } else {
        // 循环播放模式
        current_song_index = (current_song_index - 1 + 5) % 5;
    }
    update_current_song_info();
}

void music_set_volume(int volume) {
    if(volume >= 0 && volume <= 100) {
        current_volume = volume;
        if(volume_slider) lv_slider_set_value(volume_slider, volume, LV_ANIM_OFF);
    }
}

void music_set_progress(int progress) {
    if(progress >= 0 && progress <= 100) {
        current_progress = progress;
        if(progress_bar) lv_slider_set_value(progress_bar, progress, LV_ANIM_OFF);
    }
}

// 状态获取函数实现
music_state_t music_get_state(void) {
    return current_state;
}

music_mode_t music_get_mode(void) {
    return current_mode;
}

int music_get_volume(void) {
    return current_volume;
}

int music_get_progress(void) {
    return current_progress;
}

const char* music_get_current_song(void) {
    return song_titles[current_song_index];
}

const char* music_get_current_artist(void) {
    return song_artists[current_song_index];
}

int music_get_current_song_index(void) {
    return current_song_index;
}

void music_set_current_song_index(int index) {
    if(index >= 0 && index < 5) {  // 假设有5首歌
        current_song_index = index;
        update_current_song_info();
        printf("音乐播放器：切换到歌曲索引 %d\n", index);
    }
}

/**
 * @brief 上传音乐状态到云平台
 * @note 上传包含音乐状态在内的所有设备数据到MQTT云平台
 *       - 调用智能家居主界面的完整数据上传函数
 *       - 确保所有设备状态都是实时的最新数据
 *       - 避免只上传音乐数据而其他设备数据为默认值的问题
 */
static void upload_music_status_to_cloud(void) {
    // 只有在MQTT连接成功时才上传数据
    if (mqtt_cloud_get_status() != MQTT_CONNECTED) {
        return;
    }
    
    // 音乐状态发生变化，上传完整设备数据
    
    // 调用智能家居主界面的完整数据上传函数
    // 这会上传包括音乐状态在内的所有设备的实时状态
    upload_all_device_data();
}

// 刷新音乐播放器界面UI元素（用于云平台命令后的界面同步）
void refresh_music_player_ui(void) {
    // 检查音乐播放器界面是否处于活动状态
    if (!music_screen || !lv_obj_is_valid(music_screen)) {
        return; // 音乐播放器界面不活动，无需刷新
    }
    
    lv_obj_t *current_screen = lv_scr_act();
    if (current_screen != music_screen) {
        return; // 当前不在音乐播放器界面，无需刷新
    }
    
    printf("刷新音乐播放器界面UI...\n");
    
    // 1. 刷新播放/暂停按钮状态
    if (btn_play_pause) {
        lv_obj_t *label = lv_obj_get_child(btn_play_pause, 0);
        if (label) {
            if (current_state == MUSIC_STATE_PLAYING) {
                lv_label_set_text(label, LV_SYMBOL_PAUSE " 暂停");
            } else {
                lv_label_set_text(label, LV_SYMBOL_PLAY " 播放");
            }
        }
    }
    
    // 2. 刷新歌曲信息
    if (song_title_label) {
        lv_label_set_text(song_title_label, song_titles[current_song_index]);
    }
    if (artist_label) {
        lv_label_set_text(artist_label, song_artists[current_song_index]);
    }
    
    // 3. 刷新专辑封面
    if (album_cover) {
        lv_img_set_src(album_cover, song_covers[current_song_index]);
    }
    
    // 4. 刷新音量滑块和标签
    if (volume_slider) {
        lv_slider_set_value(volume_slider, current_volume, LV_ANIM_OFF);
    }
    if (volume_label) {
        char volume_text[16];
        snprintf(volume_text, sizeof(volume_text), "音量: %d", current_volume);
        lv_label_set_text(volume_label, volume_text);
    }
    
    // 5. 刷新进度条
    if (progress_bar) {
        lv_bar_set_value(progress_bar, current_progress, LV_ANIM_OFF);
    }
    
    // 6. 刷新时间标签
    if (current_time_label) {
        char current_time_str[16];
        int song_duration = 180; // 3分钟固定长度
        int current_minutes = (current_progress * song_duration / 100) / 60;
        int current_seconds = (current_progress * song_duration / 100) % 60;
        snprintf(current_time_str, sizeof(current_time_str), "%02d:%02d", current_minutes, current_seconds);
        lv_label_set_text(current_time_label, current_time_str);
    }
    
    if (total_time_label) {
        char total_time_str[16];
        int song_duration = 180; // 3分钟固定长度
        int total_minutes = song_duration / 60;
        int total_seconds = song_duration % 60;
        snprintf(total_time_str, sizeof(total_time_str), "%02d:%02d", total_minutes, total_seconds);
        lv_label_set_text(total_time_label, total_time_str);
    }
    
    // 7. 刷新播放列表选中状态
    if (playlist_list) {
        // 更新播放列表的选中项
        const int num_songs = sizeof(song_titles) / sizeof(song_titles[0]);
        lv_obj_t *child = lv_obj_get_child(playlist_list, 0);
        int index = 0;
        while (child != NULL && index < num_songs) {
            if (index == current_song_index) {
                lv_obj_set_style_bg_color(child, lv_color_hex(0x2980b9), 0);
            } else {
                lv_obj_set_style_bg_color(child, lv_color_hex(0x34495e), 0);
            }
            child = lv_obj_get_child(playlist_list, index + 1);
            index++;
        }
    }
    
    // 8. 刷新播放模式按钮
    if (btn_mode) {
        lv_obj_t *label = lv_obj_get_child(btn_mode, 0);
        if (label) {
            if (current_mode == MUSIC_MODE_REPEAT) {
                lv_label_set_text(label, LV_SYMBOL_LOOP " 循环");
            } else {
                lv_label_set_text(label, LV_SYMBOL_SHUFFLE " 随机");
            }
        }
    }
    
    printf("音乐播放器界面UI刷新完成\n");
}
